// import { abs, sqrt, log, count, multiply, sqrt, parseInt, count, pow, sum, max, mean, min } from 'mathjs'
import { create, all } from 'mathjs'
import { formulaList } from '@/utils/formula.js'
import { Message } from 'element-ui';
const config = { }
const math = create(all, config)
/**
 * abs(x)	计算一个数的绝对值。
 * log(x, y)	计算一个值的对数。
 * mod(x, y)	计算模数，即整数除法的余数
 * count(x)	  计算矩阵、数组或字符串的元素数。
 * multiply(x, y, z, ...)  将两个或多个值相乘，x * y。
 * sqrt(x)	计算一个值的平方根。
 * parseInt(x)   取整
 * count(x)	计算矩阵、数组或字符串的元素数。
 * pow(x, y)	计算 x 对 y 的幂，x ^ y。
 * sum(a, b, c, ...)	计算矩阵或具有值的列表的总和。
 * random(x)   大于等于0小于1的随机数
 * max(a, b, c, ...)	计算矩阵或具有值的列表的最大值。
 * mean(a, b, c, ...)	计算矩阵或具有值的列表的平均值。
 * min(a, b, c, ...)	计算矩阵或值列表的最小值。
 */

const operationMap = new Map();
loopSetMap();
function loopSetMap () {
    formulaList.forEach(item => {
        item.children.forEach(newItem => {
            operationMap.set(newItem.label, newItem.lowerCase)
        })
    })
}
// 计算函数
export const calculate = (editorValue) => {
    let newValue = editorValue
    let signList = []
    operationMap.forEach((v, k) => {
        if (newValue.indexOf(k) !== -1) {
            if (k === 'RAND') {
                newValue = newValue.replaceAll('RAND()', v)
            }
            if (k !== 'IF' && k !== 'IFS') {
                // 换成小写是为了适配math.js函数
                newValue = newValue.replaceAll(k, v)
            }
            signList.push(k)
        }
    })
    newValue = newValue.replaceAll('IFS(', "ifs(").replaceAll('IF(', "if(")
    signList.forEach(sign => {
        if (sign === 'INT' && newValue.indexOf('int(') !== -1) {
            newValue = allParseFunc(newValue, /\int.*?\)/g, sign)
        } else if (sign === 'IFS' && newValue.indexOf('ifs(') !== -1) {
            newValue = allParseFunc(newValue, /\ifs.*?\)/g, sign)
        } else if (sign === 'IF' && newValue.indexOf('if(') !== -1) {
            newValue = allParseFunc(newValue, /\if.*?\)/g, sign)
        }
    })
    try {
        const finallyValue = math.parse(newValue).compile().evaluate()
        console.log('计算结果:', finallyValue)
        return finallyValue
    } catch (error) {
        Message.error(error)
        return false
    }
}

function allParseFunc (newValue, regular, sign) {
    // 获取INT(*)
    const list = newValue.match(regular)
    // 通过INT(*)分隔的集合
    const strList = newValue.split(regular)
    // 获取括号内容,并输出新数组
    const valueList = list.map(item => {
        const valueNum = item.match(/(?<=\()(.+?)(?=\))/g)
        let newNum
        if (sign === 'INT') {
            newNum = intParseFunc(valueNum)
        } else if (sign === 'IFS') {
            newNum = ifsParseFunc(valueNum)
        } else if (sign === 'IF') {
            newNum = ifParseFunc(valueNum)
        }
        return newNum
    })
    // 将strList 与 valueList 数组合并
    let newStr = ''
    strList.forEach((other, index) => {
        newStr = newStr + other
        if (valueList[index] !== undefined) {
            newStr = newStr + valueList[index]
        }
    })
    return newStr
}

// 解析INT函数
function intParseFunc (valueNum) {
    return parseInt(valueNum[0].trim())
}

// 解析IF函数
function ifParseFunc (valueNum) {
    if (Array.isArray(valueNum) && valueNum.length > 0) {
        const newList = valueNum[0].split(',')
        if (eval(newList[0])) {
            return newList[1].trim()
        } else {
            return newList[2].trim()
        }
    }
}

// 解析IFS函数
function ifsParseFunc (valueNum) {
    if (Array.isArray(valueNum) && valueNum.length > 0) {
        const newList = valueNum[0].split(',')
        const num = loopJudge(newList)
        return num
    }
}

// 循环判断符号条件的数据
function loopJudge (list) {
    for (let q = 0; q < list.length; q++) {
        const item = list[q].trim()
        if (eval(item)) {
            return list[q+1].trim()
        } else {
            q++
        }
    }
}

// 匹配嵌套括号内容
export const replace_tokenizer_paranthesis = (str) => {
    var m,start = 0;
    var input;
    var s = str;
    var prefix = 'INT'
    var onmatch = function (a, b ,c ){ return [a, b + c] }
    while (m = (input = s.substring(start)).match(prefix)) {
        var offset_at_end = m.index + m[0].length;
        var numbers = str.split('(').length > 2 ? 1 : 0;
        var skip_until = "";
        var i = offset_at_end;
        for(; i < input.length; i++) {
            var c = input[i];
            if (numbers === 0) {
                break;
            } else if (c === skip_until) {
                skip_until='';
            } else if (c === '"') {
                skip_until='"';
            } else if (c === "'") {
                skip_until="'";
            } else if (c === '(') {
                numbers++;
            } else if (c === ')') {
                numbers--;
            }
        }
        if( numbers === 0 ) {
            var result = onmatch(m[0], input.substring(offset_at_end, i - 1), ')')
            s = s.substring(0, start + m.index) + result[0] + result[1] + s.substring(start+i);
            start += result[0].length;
        } else {
            start += offset_at_end;
        }
    }
    if (s) {
        console.log('=====', s)
    }
}
